home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / recio202.zip / recio.c < prev    next >
C/C++ Source or Header  |  1994-05-05  |  14KB  |  406 lines
  1. /*****************************************************************************
  2.    MODULE: recio.c
  3.   PURPOSE: record input/output functions
  4. COPYRIGHT: (C) 1994 William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.02
  8.   RELEASE: May 5, 1994
  9. *****************************************************************************/
  10.  
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <float.h>
  14. #include <limits.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include "recio.h"
  20.  
  21. #define rcol(rp)         ((rp)->r_colno)
  22. #define rflags(rp)       ((rp)->r_flags)
  23. #define rfd(rp)          ((rp)->r_fd)
  24. #define rfp(rp)          ((rp)->r_fp)
  25. #define rreclen(rp)      ((rp)->r_reclen)
  26. #define rrecsiz(rp)      ((rp)->r_recsiz)
  27. #define rfldsiz(rp)      ((rp)->r_fldsiz)
  28. #define rfldch(rp)       ((rp)->r_fldch)
  29. #define rtxtch(rp)       ((rp)->r_txtch)
  30.  
  31. /* private module variables */
  32. static REC *_RECS = NULL;              /* ptr to array of REC structures */
  33.  
  34. static REC rin  = { 1,      0,    stdin,  "stdin",     0L,
  35.                     0,      0,        0,        0,   NULL, 
  36.                     0,   NULL, RECFLDCH, RECTXTCH,  RECIN };
  37.  
  38. static REC rout = { 2, _R_WRT,   stdout, "stdout",     0L, 
  39.                     0,      0,        0,        0,   NULL, 
  40.                     0,   NULL, RECFLDCH, RECTXTCH, RECOUT };
  41.  
  42. static REC rerr = { 3, _R_WRT,   stderr, "stderr",     0L, 
  43.                     0,      0,        0,        0,   NULL, 
  44.                     0,   NULL, RECFLDCH, RECTXTCH, RECERR };
  45.  
  46. #if defined (__MSDOS__) || (MSDOS)
  47. static REC rprn = { 4, _R_WRT,   stdprn, "stdprn",     0L, 
  48.                     0,      0,        0,        0,   NULL, 
  49.                     0,   NULL, RECFLDCH, RECTXTCH, RECPRN };
  50. #define NREC      4          /* number of static record streams */
  51. #else
  52. #define NREC      3
  53. #endif
  54. #define ROPEN_MIN NREC       /* reserved for recin, etc */
  55. #define ROPEN     max(ROPEN_MAX, ROPEN_MIN)
  56.  
  57. /* public variables */
  58. REC *recin = &rin;
  59. REC *recout = &rout;
  60. REC *recerr = &rerr;
  61. #if defined (__MSDOS__) || (MSDOS)
  62. REC *recprn = &rprn;
  63. #endif
  64.  
  65. /* friend variables */
  66. char _r_nsbuf[NSBUFSIZ];     /* buffer for numeric to string conversions */
  67.  
  68. /* Support functions */
  69. /****************************************************************************/
  70. static void                  /* returns nothing                             */
  71.     _rexit(                  /* at program exit, clean up                   */
  72.         void)                /* no arguments                                */
  73. /****************************************************************************/
  74. {
  75.     /* free recin buffers */
  76.     free(rflds(recin));
  77.     free(rrecs(recin));
  78.     rflds(recin) = NULL;
  79.     rfldsiz(recin) = 0;
  80.     rrecs(recin) = NULL;
  81.     rrecsiz(recin) = 0;
  82.     rreclen(recin) = 0;
  83.  
  84.     /* ensure all record streams closed */
  85.     rcloseall();
  86. }
  87.  
  88. /****************************************************************************/
  89. void                         /* return error number (0=no error)            */
  90.     _rsetexitfn(             /* register _rexit function with atexit()      */
  91.         REC *rp)             /* record pointer                              */
  92. /****************************************************************************/
  93. {
  94.     static int once=0;       /* register exit fn only once */
  95.  
  96.     if (!once) {
  97.  
  98.         /* execute this path at most one time */
  99.         once++;
  100.  
  101.         /* if atexit() fails to register _rexit() function */
  102.         if (atexit(_rexit)) {
  103.  
  104.            /* register warning */
  105.            rsetwarn(rp, R_WNOREG);
  106.         }
  107.     }
  108. } 
  109.  
  110. /****************************************************************************/
  111. int                          /* return error number (0=no error)            */
  112.     _rismode(                /* check for correct mode                      */
  113.         REC *rp,             /* record pointer                              */
  114.         int mode)            /* mode (0=read; !0=write/append)              */
  115. /****************************************************************************/
  116. {
  117.     int errnum=0;            /* error number (0=mode ok, !0=invalid mode) */
  118.     unsigned smode;          /* stream mode */
  119.  
  120.     /* if stream _R_WRT flag does not match mode */
  121.     smode = rflags(rp) & _R_WRT;
  122.     if ((mode && !smode) || (!mode && smode)) {
  123.         errnum = rseterr(rp, R_EINVMOD);
  124.     }
  125.     return errnum;
  126. }
  127.  
  128. /****************************************************************************/
  129. int                          /* return error number (0=no error)            */
  130.     _rstatus(                /* check stream for errors                     */
  131.         REC *rp,             /* record pointer                              */
  132.         int mode)            /* mode (0=read; !0=write/append)              */
  133. /****************************************************************************/
  134. {
  135.     int errnum=0;            /* error number */
  136.  
  137.     /* test for valid record pointer */
  138.     if (!risvalid(rp)) {
  139.         errnum = rseterr(NULL, EINVAL);
  140.         goto done;
  141.     }
  142.     
  143.     /* check mode */
  144.     errnum = _rismode(rp, mode);
  145.     if (errnum) goto done;
  146.  
  147.     /* if record 0 and write mode */
  148.     if (!rrecno(rp) && mode) {
  149.         rrecno(rp)++;
  150.     }
  151.  
  152.     /* test for previous error */
  153.     errnum = rerror(rp);
  154.  
  155. done:
  156.     return (errnum);
  157. }
  158.  
  159. /****************************************************************************/
  160. static void                  /* returns nothing                             */
  161.     _rfree(                  /* free the memory allocated to a record       */
  162.         REC *rp)             /* record pointer                              */
  163. /****************************************************************************/
  164. {
  165.     if (risvalid(rp)) {
  166.         free(rflds(rp));
  167.         free(rrecs(rp));
  168.         if (rfp(rp)) fclose(rfp(rp));
  169.         memset(rp, 0, sizeof(REC));
  170.     }
  171. }
  172.  
  173. /* User functions */
  174. /****************************************************************************/
  175. REC *                        /* return record pointer                       */
  176.     ropen(                   /* open a record stream for reading            */
  177.         const char *fname,   /* name of file to open                        */
  178.         const char *mode)    /* type of mode used to open file              */
  179. /****************************************************************************/
  180. {
  181.     REC *rp = _RECS;         /* record pointer */
  182.     int  i;                  /* count of REC structures */
  183.     int  ch;                 /* first character of mode */
  184.     
  185.     errno = 0;
  186.  
  187.     /* only modes currently supported are "r", "w", and "a" */
  188.     ch = tolower(*mode);
  189.     if (!(ch=='r' || ch=='w' || ch=='a')) {
  190.         rp = NULL;
  191.         rseterr(NULL, EINVAL);
  192.         goto done;
  193.     }
  194.  
  195.     /* allocate memory for array of REC structures */
  196.     if (!rp) {
  197.         do {
  198.             /* note: no memory allocation needed for recin, etc */
  199.             rp = _RECS = (REC *) calloc(ROPEN-NREC, sizeof(REC));
  200.             if (!rp) {
  201.                 if (rseterr(NULL, ENOMEM)) goto done;
  202.             }
  203.         } while (!rp);
  204.     }
  205.  
  206.     /* search thru REC structures until empty position found */
  207.     for (i=NREC+1; i <= ROPEN; i++, rp++) {
  208.         if (!rfd(rp)) {
  209.             rfd(rp) = i;
  210.             break;
  211.         }
  212.     }
  213.     /* error if out of positions */
  214.     if (i > ROPEN) {
  215.         rp = NULL;
  216.         rseterr(NULL, EMFILE);
  217.         goto done;
  218.     }
  219.  
  220.     /* open file */
  221.     rfp(rp) = fopen(fname, mode);
  222.     if (!rfp(rp)) {
  223.         rclose(rp);
  224.         rp = NULL;
  225.         /* if error other than path/file not found */
  226.         if (errno != ENOENT) {
  227.             rseterr(NULL, errno);
  228.         }
  229.         goto done;
  230.     }
  231.  
  232.     /* initialize */
  233.     if (ch != 'r') rflags(rp)  |= _R_WRT;
  234.     rnames(rp)  = fname;
  235.     rrecno(rp)  = 0L;
  236.     rfldno(rp)  = 0;
  237.     rcol(rp)    = 0;
  238.     rrecsiz(rp) = 0;
  239.     rreclen(rp) = 0;
  240.     rrecs(rp)   = NULL;
  241.     rfldsiz(